package tenant_reference_impl

import (
	"context"
	"nexus/dto"
	"nexus/internal/svc"
	"nexus/internal/types"
	"nexus/model"
	"nexus/utils"
	"nexus/utils/errorx"

	"github.com/zeromicro/go-zero/core/logc"
	"gorm.io/gorm"
)

type TenantReferenceImpl struct {
	svc *svc.ServiceContext
}

func NewTenantReferenceImpl(svc *svc.ServiceContext) TenantReference {
	return &TenantReferenceImpl{
		svc: svc,
	}
}

// 管理员权限校验
func (impl *TenantReferenceImpl) adminAuth(ctx context.Context) (bool, error) {
	// 权限校验
	userID := utils.GetUserIDFromContext(ctx)
	isSuper, err := model.NewUserClient((*gorm.DB)(impl.svc.NexusDB)).IsAdminByID(userID)
	if err != nil {
		return false, err
	}
	if !isSuper {
		return false, errorx.NoPermissionError
	}
	return true, nil
}

// 创建租户
func (impl *TenantReferenceImpl) CreateTenant(ctx context.Context, req *types.CreateTenantReq) (*dto.Tenant, error) {
	// 权限校验
	isSuper, err := impl.adminAuth(ctx)
	if err != nil || !isSuper {
		if err != errorx.NoPermissionError {
			logc.Errorf(ctx, "管理员权限校验失败: %v", err)
			return nil, err
		}
		return nil, err
	}

	// 构建请求参数对应的model层对象
	tenant := &model.Tenant{
		Name:          req.Name,
		ServerStartAt: req.ServerStartAt,
		ServerEndAt:   req.ServerEndAt,
	}

	// 调用model层创建租户
	err = model.NewTenantClient((*gorm.DB)(impl.svc.NexusDB)).CreateTenant(tenant)
	if err != nil {
		return nil, errorx.HandlerSqlError(err)
	}

	// 将model层返回的Tenant转换为DTO层的Tenant
	data := dto.NewDTOTransfer().TenantToDTO(tenant)

	return data, err
}

// 查询租户列表
func (impl *TenantReferenceImpl) TenantList(ctx context.Context, req *types.TenantListReq) ([]*dto.Tenant, error) {
	// 权限校验
	isSuper, err := impl.adminAuth(ctx)
	if err != nil || !isSuper {
		if err != errorx.NoPermissionError {
			logc.Errorf(ctx, "管理员权限校验失败: %v", err)
			return nil, err
		}
		return nil, err
	}

	// 构建查询条件
	condition := &model.TenantCondition{
		Name:          req.Name,
		ServerStartAt: req.ServerStartAt,
		ServerEndAt:   req.ServerEndAt,
	}

	// 调用model层获取用户列表
	tenants, err := model.NewTenantClient((*gorm.DB)(impl.svc.NexusDB)).BatchFindTenantByCondition(condition, req.Page, req.Size)
	if err != nil {
		logc.Errorf(ctx, "用户列表查询错误: %v", err)
		return nil, err
	}

	// 将model层的User列表转换为DTO层的User列表
	var tenantDTOs []*dto.Tenant
	for _, tenant := range tenants {
		tenantDTO := dto.NewDTOTransfer().TenantToDTO(tenant)
		tenantDTOs = append(tenantDTOs, tenantDTO)
	}

	return tenantDTOs, nil
}

// 更新租户
func (impl *TenantReferenceImpl) UpdateTenant(ctx context.Context, req *types.UpdateTenantReq) (*dto.Tenant, error) {
	// 权限校验
	isSuper, err := impl.adminAuth(ctx)
	if err != nil || !isSuper {
		if err != errorx.NoPermissionError {
			logc.Errorf(ctx, "管理员权限校验失败: %v", err)
			return nil, err
		}
		return nil, err
	}

	tenantID := req.ID

	// 构建更新条件
	updateTenant := &model.Tenant{
		ID: tenantID,
	}
	if req.Name != "" {
		updateTenant.Name = req.Name
	}
	if req.ServerStartAt != "" {
		updateTenant.ServerStartAt = req.ServerStartAt
	}
	if req.ServerEndAt != "" {
		updateTenant.ServerEndAt = req.ServerEndAt
	}

	// 调用model层更新用户信息
	err = model.NewTenantClient((*gorm.DB)(impl.svc.NexusDB)).UpdateTenant(updateTenant)
	if err != nil {
		logc.Errorf(ctx, "用户更新错误: %v", err)
		return nil, err
	}

	// 调用model层获取租户详情
	tenant, err := model.NewTenantClient((*gorm.DB)(impl.svc.NexusDB)).FindTenantByCondition(&model.TenantCondition{
		ID: tenantID,
	})
	if err != nil {
		logc.Errorf(ctx, "用户详情查询错误: %v", err)
		return nil, err
	}

	// 将model层的Tenant转换为DTO层的Tenant
	tenantDTO := dto.NewDTOTransfer().TenantToDTO(tenant)

	return tenantDTO, nil
}
